package com.example.liuke.guangguang.untils;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

/**
 * Created by liuke on 2018/1/17.
 * 这里还有一个局限：仅限同行数的xml比对，多出了节点还没发比对，以后要修改
 */

public class xmlcomparison {
    private String xmlurlold, xmlurlnew;//xml的地址
    private List<HashMap<String, String>> hashMapListold = new ArrayList<>();//老的xml所有url集合包含它的保存地址
    private List<HashMap<String, String>> hashMapListnew = new ArrayList<>();
    private List<HashMap<String, String>> hashMapListtemp = new ArrayList<>();
    private List<HashMap<String, String>> hashMapListtemp2 = new ArrayList<>();
    private HashMap<String, String> hashMap;
    private List<HashMap<String, String>> hashMapListload = new ArrayList<>();
    private List<HashMap<String, String>> hashMapListdel = new ArrayList<>();

    //后遭方法，要用到super的时候是使用父对象的时候，此处不用
    public xmlcomparison(String xmlurl1, String xmlurl2) {
        this.xmlurlold = xmlurl1;
        this.xmlurlnew = xmlurl2;
        //获取老的xml所有url集合
        analyze(xmlurlold, hashMapListtemp);
        hashMapListold = hashMapListtemp;
        System.out.println("老xml的所有url的hashmap集合数量： " + hashMapListold.size());
        for (HashMap<String, String> hashMap : hashMapListold) {
            System.out.println("旧集合内的东西：" + hashMap.get("path"));
            System.out.println("旧集合内的东西：" + hashMap.get("URL"));
        }
        //获取新的xml所有url集合
        analyze(xmlurlnew, hashMapListtemp2);
        hashMapListnew = hashMapListtemp2;
        System.out.println("新xml的所有url的hashmap集合数量： " + hashMapListnew.size());
        for (HashMap<String, String> hashMap : hashMapListnew) {
            System.out.println("新集合内的东西：" + hashMap.get("path"));
            System.out.println("新集合内的东西：" + hashMap.get("URL"));
        }
    }

    //比对获取下载列表
    public List<HashMap<String, String>> GetDownloadList() {
        //比对旧的，没有的就拿出来  hashMapListnew
        for (int j = 0; j < hashMapListnew.size(); j++) {//要考虑一下是空的是否有影响
            String url = hashMapListnew.get(j).get("URL");
            System.out.println("分割后的数据11：" + url);
            String[] UrlArray = split(url);
            String oldurl = hashMapListold.get(j).get("URL");
            System.out.println("分割后的数据12：" + oldurl);
            if (null != UrlArray && UrlArray.length > 0) {
                for (int i = 0; i < UrlArray.length; i++) {
                    System.out.println("分割后的数据：" + UrlArray[i] + "  " + oldurl + "  " + oldurl.contains(UrlArray[i]));
                    //分割出来的每一个到老的里面去查找有没有这个字符串，没有的话就添加到下载列表里面去
                    //比对的话只能是对应着比对，不然一个标签中的去比对其他标签中肯定都是没有的,对应着比也不会出现比对其他空的肯定就是没得，导致数据重复
                    //拿来比对的东西是不能有空的，空的去比对有的肯定都是没有的，不能到所有的里面去比对,
                    if ((!UrlArray[i].equals("")) && (!oldurl.contains(UrlArray[i]))) {
                        System.out.println("不包含的：" + UrlArray[i]);
                        HashMap<String, String> single = new HashMap<>();
                        single.put("path", hashMapListnew.get(j).get("path"));
                        single.put("URL", UrlArray[i]);
                        hashMapListload.add(single);
                    }
                }
            }
        }
        return hashMapListload;
    }

    //比对获取删除列表
    public List<HashMap<String, String>> GetDeleteList() {
        //比对新的，没有的就拿出来  放入删除列表
        for (int j = 0; j < hashMapListold.size(); j++) {//要考虑一下是空的是否有影响
            String url = hashMapListold.get(j).get("URL");
            System.out.println("分割后的数据11：" + url);
            String[] UrlArray = split(url);
            String newurl = hashMapListnew.get(j).get("URL");
            System.out.println("分割后的数据12：" + newurl);
            if (null != UrlArray && UrlArray.length > 0) {
                for (int i = 0; i < UrlArray.length; i++) {
                    System.out.println("分割后的数据：" + UrlArray[i] + "  " + newurl + "  " + newurl.contains(UrlArray[i]));
                    //分割出来的每一个到老的里面去查找有没有这个字符串，没有的话就添加到下载列表里面去
                    //比对的话只能是对应着比对，不然一个标签中的去比对其他标签中肯定都是没有的,对应着比也不会出现比对其他空的肯定就是没得，导致数据重复
                    //拿来比对的东西是不能有空的，空的去比对有的肯定都是没有的，不能到所有的里面去比对,
                    if ((!UrlArray[i].equals("")) && (!newurl.contains(UrlArray[i]))) {
                        System.out.println("不包含的：" + UrlArray[i]);
                        HashMap<String, String> single = new HashMap<>();
                        single.put("path", hashMapListold.get(j).get("path"));
                        single.put("URL", UrlArray[i]);
                        hashMapListdel.add(single);
                    }
                }
            }
        }
        return hashMapListdel;
    }

    //xml比对，目标是把差异找出来  一个xml递归解析的时候 一个内容解析出来，另外一个xml解析找到这个值，循环比对内容
    //拿出来的东西最好就是文件存储路径加上文件名  删除的一个list集合，下载的一个集合，hashmap存两个键值对，一个是本地存储路径，一个是下载地址
    public void analyze(String xmlurl, List<HashMap<String, String>> hashMapListtemp) {
        //每次使用中间变量的时候清空，以便其他使用，通用性
        hashMapListtemp.clear();
        Document document;
        //创建SAXReader对象  

        SAXReader reader = new SAXReader();
        //读取文件 转换成Document  
        try {
            document = reader.read(new File(xmlurl));
            document.setXMLEncoding("utf-8");
            //获取根节点元素对象  
            Element root = document.getRootElement();
            //遍历  
            listnodesbidui(root, hashMapListtemp);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //遍历当前节点下的所有子节点
    public void listnodesbidui(Element node, List<HashMap<String, String>> hashMapListtemp) {
        System.out.println("dom4jxml当前子节点的名称：" + node.getName());
        //首先获取当前子节点的所有属性节点
        List<Attribute> list = node.attributes();
        //遍历属性节点
        for (Attribute attribute : list) {
            System.out.println("dom4jxml属性:" + attribute.getName() + ":" + attribute.getValue());
        }
        if (node.getName().equals("path")) {
            hashMap = new HashMap<>();
            System.out.println("dom4jxml" + node.getName() + ":" + node.getText());
            hashMap.put("path", node.getText());//保存路径  是否现在将下载路径分割开来  这是一种做法 ，还有一种做法就是先保存，之后比对的时候在分割比对
        } else if (node.getName().equals("URL")) {//url可能为空的
            hashMap.put("URL", node.getText());//这是下载地址，到时候比对的是url，这里还没有分割
            hashMapListtemp.add(hashMap);
            System.out.println("xml的所有url的hashmap集合数量" + hashMapListtemp.size());
        }
        //同时迭代当前节点下面的所有子节点，使用递归  
        Iterator<Element> iterator = node.elementIterator();
        while (iterator.hasNext()) {
            Element e = iterator.next();
            listnodesbidui(e, hashMapListtemp);
        }
    }

    //按“；”分割url获取每一个图片下载地址
    public static String[] split(String string) {
        String[] temp = null;
        temp = string.split(";");
        return temp;
    }
}
